Testing software systems can be an expensive and labor-intensive process. In particular, software systems such as Enterprise Resource Planning (ERP) systems, may include many modules, which each under certain circumstances may need to be tested in order to validate that the software system is operating as expected. Many of the software modules are customizable and can be made to perform according to an organization's specific needs by manipulating configuration elements (e.g., values in configuration tables or user generated code). Manipulating a configuration element (e.g., by adding, deleting, or modifying a configuration element) may affect many transactions that may be executed on the software system. Thus, the need to validate configuration elements is often one of the primary reasons that tests need to be run in many organizations. However, understanding the dependencies between transactions and configuration elements often affects the coding and maintenance phases of the system, and may involve root-cause analysis of an application and its code. Known methods are complicated and expensive; often when a system is very large the complexity of analyzing the code may be too big.
Thus, determining what tests to run in order to validate a configuration element is not a trivial task. In particular, it is difficult to determine which of the many transactions that may be performed on a software system may be dependent on a certain configuration element. Often, due to unknown dependencies, configuration elements may have unintended and/or unexpected side effects on transactions performed on a software system, which a tester may not be aware of. Since tests are usually designed and run by each organization separately on the organization's systems, this means that each organization must build up the necessary knowledge of such dependencies, and independently discover which transactions should be tested when validating different configuration elements. Gaining this knowledge may require much effort and experience; in the meantime, testing the software systems may be a less effective and prolonged process.